package com.xiangge.demo;

import java.util.Arrays;
import java.util.Scanner;

public class ArrayDemo1 {
    public static void main7(String[] args) {
        /*有三个班级，第一个班级3个学生，第二个班级4个学生，第三个班级5个学生。
        要求通过键盘录入三个班级学生的成绩，并计算每个班级学生的的平均成绩。*/
        // 创建三个数组代表三个班级
        int[] class1 = new int[3];
        // 使用for循环变量班级，然后录入成绩
        for (int i = 0; i < class1.length; i++) {
            // 使用Scanner方法来录入成绩
            System.out.println("请录入一班第" + (i+1) + "个学生的成绩为：");
            class1[i] = new Scanner(System.in).nextInt();
        }
        int[] class2 = new int[4];
        for (int i = 0; i < class2.length; i++) {
            // 使用Scanner方法来录入成绩
            System.out.println("请录入二班第" + (i+1) + "个学生的成绩为：");
            class2[i] = new Scanner(System.in).nextInt();
        }
        int[] class3 = new int[5];
        for (int i = 0; i < class3.length; i++) {
            // 使用Scanner方法来录入成绩
            System.out.println("请录入三班第" + (i+1) + "个学生的成绩为：");
            class3[i] = new Scanner(System.in).nextInt();
        }
        // 定义一个二维数组将每个一维数组放入
        int[][] school = new int[3][];
        school[0] = class1;
        school[1] = class2;
        school[2] = class3;
        // 遍历二维数组，得到其中包含的每个子数组
        for (int i = 0; i < school.length; i++) {
            int[] arr = school[i];
            // 最后要求每个班成绩的平均值，再定义一个double类型的变量
            double score = 0.0;
            // 再将二维数组中得到的每个子数组遍历一遍
            for (int num : arr) {
                score += num;
            }
            /*或者不使用for增强方法，就使用arr.length.fori进行遍历
            for (int j = 0; j < arr.length; j++) {
                score = score + arr[j];
            }*/
            // 输出每个班的总成绩，然后再除以每个班的人数，每个班的人数引用arr.length
            System.out.println("第"+ (i+1) + "个班的成绩平均分为：" + score / arr.length);
        }
    }
    public static void main6(String[] args) {
        // 遍历一个二维数组{{5, 12}, {60, 18, 77}, {76, 45, 28, 59, 72}}，如果遇到60就结束
        int[][] arr = {{5, 12}, {60, 18, 77}, {76, 45, 28, 59, 72}};
        // 遍历二维数组，首先会得到他的子数组{5, 12} 和 {60, 18, 77} 和 {76, 45, 28, 59, 72}
        outer:for (int i = 0; i < arr.length; i++) {
            int[] ziArr = arr[i];
            // 再对遍历后的子数组遍历，得到里面的元素
            inner:for (int j = 0; j < ziArr.length; j++) {
                // 然后使用if双选结构判断
                if (ziArr[j] == 60){
                    break outer; // 因为break只会结束当前所在的循环，使用要用带标签的break
                        // 所以对最外层的循环添加一个标签outer，内层循环添加inner
                        // 然后用break + 标签结束对应的循环
                }else {
                    System.out.println(ziArr[j]);
                }
            }
        }
    }
    public static void main5(String[] args) {
        /*
        在数组{5, 12, 90, 18, 77, 76, 45, 28, 59, 72}中索引为2的位置添加元素222
        */
        int[] arr = {5, 12, 90, 18, 77, 76, 45, 28, 59, 72};
        // 添加元素会改变原数组的长度，要新建一个数组,数组长度+1
        int[] newArr = new int[arr.length+1];
        // 遍历原数组，将[0,1]的索引元素放入新数组[0,1]中，[2,9]的索引元素放入新数组[3,10]中
        // 新数组中索引2位置的元素就为插入的元素

        //第一种实现写法
        for (int i = 0; i < arr.length; i++) {
            // 使用if结构将元素分别放入,当索引i在[0,1]之间时，同位放入新数组
            if (i >= 0 && i <= 1){
                newArr[i] = arr[i];
            }
            // 反之当索引i在[2,9]之间时，放入新数组[3,10]中
            else {
                newArr[i + 1] = arr[i];
            }
        }
        // 最后将新数组中索引2位置的默认元素0改为需要添加的元素
        newArr[2] = 222;
        System.out.println(Arrays.toString(newArr));


        // 第二种实现写法，除了用if判断外，也可以将原数组分开遍历
        // 先遍历原数组与新数组索引位元素相同的
        for (int i = 0; i < 2; i++) {
            newArr[i] = arr[i];
        }
        // 再遍历原数组的余下部分，将其赋值到新数组该放的位置中
        for (int i = 2; i < arr.length; i++) {
            newArr[i + 1] = arr[i];
        }
        newArr[2] = 222;
        System.out.println(Arrays.toString(newArr));
    }
    public static void main4(String[] args) {
        /*
        删除数组{5, 12, 90, 18, 77, 76, 45, 28, 59, 72}索引为2的元素
        */
        // 方法一：将索引[3,9]的元素整体向前挪一个位置，再将最大索引位置的元素修改为0
        int[] arr = {5, 12, 90, 18, 77, 76, 45, 28, 59, 72};
        // 使用for循环遍历一遍数组
        for (int i = 0; i < arr.length; i++) {
            // 使用if单选结构，当数组的索引到i=3时，让索引i-1的元素赋值成索引i的元素
            if (i > 2){
                arr[i - 1] = arr[i];
            }
        }
        arr[arr.length -1] = 0;
        System.out.println(Arrays.toString(arr));
    }
    public static void main3(String[] args) {
        /*
        将数组{5, 12, 90, 18, 77, 76, 45, 28, 59, 72}反转
        */
        // 方法一：创建一个临时遍历来装数组元素，用两个指针来遍历数组
        int[] arr = {5, 12, 90, 18, 77, 76, 45, 28, 59, 72};
        // 定义int类型的变量
        int temp = 0;
        // for循环遍历数组，分别用start和end来代表两个指针，分别从前往后和从后往前开始遍历
        for (int start = 0 ,end = arr.length-1; start <= end; start++ ,end--) {
            temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        System.out.println(Arrays.toString(arr));

        // 方法二：创建一个等长的默认的新数组，将原数组从后往前遍历放进新数组中
        int[] newArr = new int[10];
        // 使用for循环从后往前遍历数组
        for (int i = arr.length-1; i >= 0; i--) {
            newArr[arr.length-1-i] = arr[i];
        }
        System.out.println(Arrays.toString(newArr));
    }
    public static void main2(String[] args) {
        /*
        获取元素59在数组{5, 12, 90, 18, 77, 76, 45, 28, 59, 72}中的位置
        */
        // 定义一个已知的数组
        int[] arr = {5, 12, 90, 18, 77, 76, 45, 28, 59, 72};
        // 假设元素59存在索引，这里直接用-1作为元素的索引
        int num = 59;
        int numIndex = -1; // 在数组中默认索引是-1的元素不存在
        // 遍历数组寻找
        for (int i = 0; i < arr.length; i++) {
            // 使用if单选结构判断
            if (num == arr[i]){
                numIndex = i;
                break;
            }
        }
        // 再使用if双选结构，来分开展示情况
        if (numIndex == -1){
            System.out.println("数组中不存在该元素");
        }else {
            System.out.println("数组中存在该元素，元素所在的位置索引为:" + numIndex);
        }
    }
    public static void main1(String[] args) {
        /*
        获取数组最值，数组{5, 12, 90, 18, 77, 76, 45, 28, 59, 72}
        */
        // 定义一个已知的数组,为int类型
        int[] arr = {5, 12, 90, 18, 77, 76, 45, 28, 59, 72};
        // 创建int类型的变量
        // 先将数组中索引为0的元素赋值给max，再与其他元素进行比较
        int max = arr[0], min = arr[0];
        // 使用for循环，遍历数组
        // 遍历从索引1开始，是因为将索引为0的元素赋值给了max，不需要在用索引为0的和0比较
        for (int i = 1; i < arr.length; i++) {
            // 使用if结构
            if (max < arr[i]){
                max = arr[i];
            }
            if (min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("数组的最大值为：" + max);
        System.out.println("数组的最小值为：" + min);
    }
}
